/*
    * Copyright (C) 2011 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.util.concurrent;
  
  import com.google.common.base.Preconditions;
  
  import junit.framework.TestCase;
  
  import org.mockito.Mockito;
  
  import java.util.concurrent.CancellationException;
  import java.util.concurrent.Executor;
  import java.util.concurrent.Future;
  import java.util.concurrent.TimeUnit;
  
  import javax.annotation.Nullable;
  
  /**
   * Test for {@link FutureCallback}.
   *
   * @author Anthony Zana
   */
  public class FutureCallbackTest extends TestCase {
    public void testSameThreadSuccess() {
      SettableFuture<String> f = SettableFuture.create();
      MockCallback callback = new MockCallback("foo");
      Futures.addCallback(f, callback);
      f.set("foo");
    }
  
    public void testExecutorSuccess() {
      CountingSameThreadExecutor ex = new CountingSameThreadExecutor();
      SettableFuture<String> f = SettableFuture.create();
      MockCallback callback = new MockCallback("foo");
      Futures.addCallback(f, callback, ex);
      f.set("foo");
      assertEquals(1, ex.runCount);
    }
  
    // Error cases
    public void testSameThreadExecutionException() {
      SettableFuture<String> f = SettableFuture.create();
      Exception e = new IllegalArgumentException("foo not found");
      MockCallback callback = new MockCallback(e);
      Futures.addCallback(f, callback);
      f.setException(e);
    }
  
    public void testCancel() {
      SettableFuture<String> f = SettableFuture.create();
      FutureCallback<String> callback =
          new FutureCallback<String>() {
            private boolean called = false;
            @Override
            public void onSuccess(String result) {
              fail("Was not expecting onSuccess() to be called.");
            }
  
            @Override
            public synchronized void onFailure(Throwable t) {
              assertFalse(called);
              assertTrue(t instanceof CancellationException);
              called = true;
            }
          };
      Futures.addCallback(f, callback);
      f.cancel(true);
    }
  
    public void testThrowErrorFromGet() {
      Error error = new AssertionError("ASSERT!");
      ListenableFuture<String> f = ThrowingFuture.throwingError(error);
      MockCallback callback = new MockCallback(error);
      Futures.addCallback(f, callback);
    }
  
    public void testRuntimeExeceptionFromGet() {
      RuntimeException e = new IllegalArgumentException("foo not found");
      ListenableFuture<String> f = ThrowingFuture.throwingRuntimeException(e);
      MockCallback callback = new MockCallback(e);
      Futures.addCallback(f, callback);
    }
  
    public void testOnSuccessThrowsRuntimeException() throws Exception {
      RuntimeException exception = new RuntimeException();
     String result = "result";
     SettableFuture<String> future = SettableFuture.create();
     @SuppressWarnings("unchecked") // Safe for a mock
     FutureCallback<String> callback = Mockito.mock(FutureCallback.class);
     Futures.addCallback(future, callback);
     Mockito.doThrow(exception).when(callback).onSuccess(result);
     future.set(result);
     assertEquals(result, future.get());
     Mockito.verify(callback).onSuccess(result);
     Mockito.verifyNoMoreInteractions(callback);
   }
 
   public void testOnSuccessThrowsError() throws Exception {
     class TestError extends Error {}
     TestError error = new TestError();
     String result = "result";
     SettableFuture<String> future = SettableFuture.create();
     @SuppressWarnings("unchecked") // Safe for a mock
     FutureCallback<String> callback = Mockito.mock(FutureCallback.class);
     Futures.addCallback(future, callback);
     Mockito.doThrow(error).when(callback).onSuccess(result);
     try {
       future.set(result);
       fail("Should have thrown");
     } catch (TestError e) {
       assertSame(error, e);
     }
     assertEquals(result, future.get());
     Mockito.verify(callback).onSuccess(result);
     Mockito.verifyNoMoreInteractions(callback);
   }
 
   public void testWildcardFuture() {
     SettableFuture<String> settable = SettableFuture.create();
     ListenableFuture<?> f = settable;
     FutureCallback<Object> callback = new FutureCallback<Object>() {
       @Override
       public void onSuccess(Object result) {}
 
       @Override
       public void onFailure(Throwable t) {}
     };
     Futures.addCallback(f, callback);
   }
 
   private class CountingSameThreadExecutor implements Executor {
     int runCount = 0;
     @Override
     public void execute(Runnable command) {
       command.run();
       runCount++;
     }
   }
 
   // TODO(user): Move to testing, unify with RuntimeExceptionThrowingFuture
 
   /**
    * A {@link Future} implementation which always throws directly from calls to
    * get() (i.e. not wrapped in ExecutionException.
    * For just a normal Future failure, use {@link SettableFuture}).
    *
    * <p>Useful for testing the behavior of Future utilities against odd futures.
    *
    * @author Anthony Zana
    */
   private static class ThrowingFuture<V> implements ListenableFuture<V> {
     private final Error error;
     private final RuntimeException runtime;
 
     public static <V> ListenableFuture<V> throwingError(Error error) {
       return new ThrowingFuture<V>(error);
     }
 
     public static <V> ListenableFuture<V>
         throwingRuntimeException(RuntimeException e) {
       return new ThrowingFuture<V>(e);
     }
 
     private ThrowingFuture(Error error) {
       this.error = Preconditions.checkNotNull(error);
       this.runtime = null;
     }
 
     public ThrowingFuture(RuntimeException e) {
       this.runtime = Preconditions.checkNotNull(e);
       this.error = null;
     }
 
     @Override
     public boolean cancel(boolean mayInterruptIfRunning) {
       return false;
     }
 
     @Override
     public boolean isCancelled() {
       return false;
     }
 
     @Override
     public boolean isDone() {
       return true;
     }
 
     @Override
     public V get() {
       throwOnGet();
       throw new AssertionError("Unreachable");
     }
 
     @Override
     public V get(long timeout, TimeUnit unit) {
       throwOnGet();
       throw new AssertionError("Unreachable");
     }
 
     @Override
     public void addListener(Runnable listener, Executor executor) {
       executor.execute(listener);
     }
 
     private void throwOnGet() {
       if (error != null) {
         throw error;
       } else {
         throw runtime;
       }
     }
   }
 
   private final class MockCallback implements FutureCallback<String> {
     @Nullable private String value = null;
     @Nullable private Throwable failure = null;
     private boolean wasCalled = false;
 
     MockCallback(String expectedValue) {
       this.value = expectedValue;
     }
 
     public MockCallback(Throwable expectedFailure) {
       this.failure = expectedFailure;
     }
 
     @Override
     public synchronized void onSuccess(String result) {
       assertFalse(wasCalled);
       wasCalled = true;
       assertEquals(value, result);
     }
 
     @Override
     public synchronized void onFailure(Throwable t) {
       assertFalse(wasCalled);
       wasCalled = true;
       assertEquals(failure, t);
     }
   }
 }